home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 1 / QRZ Ham Radio Callsign Database - December 1993.iso / ucsd / packet / tcpip / mac / sftksrcs.hqx / SoftKiss.src.1.8 / sfk_cdev.c next >
Encoding:
C/C++ Source or Header  |  1993-03-13  |  9.1 KB  |  472 lines
  1. /*
  2.  * SoftKiss control panel
  3.  * by Aaron Wohl / N3LIW (aw0g+@andrew.cmu.edu) jul 1990
  4.  * 6393 Penn Ave #303
  5.  * Pittsburgh PA, 15206
  6.  * work: (412)-268-5032
  7.  */
  8.  
  9. #include <cdev.h>
  10. #include "sfk_core.h"
  11. #include "sfk_core_private.h"
  12. #include "sfk_drvr_find.h"
  13. #include "sfk_os_preserve.h"
  14.  
  15. /*
  16.  * Think has dp as a dialog peek
  17.  * with strict checking on the compiler complains on use of
  18.  * dp so we use dpp
  19.  */
  20. #define dptr ((DialogPtr)dp)
  21.  
  22. /*
  23.  * number of ports handled by cdev
  24.  */
  25. #define CDEV_PORTS (2)
  26.  
  27. /*
  28.  * info for each ditem
  29.  */
  30. struct a_ditem_R {
  31.     short type;
  32.     Handle ctl;
  33.     Rect box;
  34. };
  35. typedef struct a_ditem_R a_ditem,*a_ditem_pt;
  36.  
  37. /*
  38.  * indexes into ditl
  39.  */
  40. enum {
  41.     fn_a_off=1,
  42.     fn_a_kiss=2,
  43.     fn_a_tnc=3,
  44.     fn_a_text=4,
  45.  
  46.     fn_b_off=5,
  47.     fn_b_kiss=6,
  48.     fn_b_tnc=7,
  49.     fn_b_text=8,
  50.  
  51.     fn_line1=9,
  52.     fn_line2=10,
  53.  
  54.     fn_title=11,
  55.     fn_modem_text=12,
  56.     fn_printer_text=13,
  57.     fn_LAST=13
  58. };
  59.  
  60. /*
  61.  * allocate some vars with newptr so they don't float around and
  62.  * can be passed to system calls
  63.  */
  64. struct fs_t_R {
  65.     a_ditem items[fn_LAST+1];
  66.     Pattern cdev_gray;    /*no quickdraw vars to access gray*/
  67.  
  68.     short ref_num;        /*SoftKiss driver number*/
  69.     int active;            /*are in the front*/
  70.     int port_err[CDEV_PORTS]; /*non zero if last control call on port failed*/
  71.     int init_done;
  72.     int port_a_mode;    /*setting for a port*/
  73.     int port_b_mode;    /*setting for b port*/
  74.     dyn_text dt;        /*dynamic text info*/
  75. };
  76. typedef struct fs_t_R fs_t,*fs_t_pt;
  77.  
  78. struct SoftKiss : cdev {
  79.     fs_t *fs;            /*fixed allocated stuff*/
  80.     void set_item_value(int item,int setting);
  81.     void set_item_hilite(int item,int setting);
  82.     void find_driver(void);
  83.     void set_display(void);
  84.     void working_SetIText(int item,char *new_text);
  85.     void ReadItems(void);
  86.     void send_cmd(int portno,char *msg);
  87.     void read_driver_status(char *out_buf,long out_buf_size);
  88.     void read_1_driver_status(int portno,char *out_buf,long out_buf_size);
  89.     void send_msg(int portno,char *msg,char *out_buf,long out_buf_size);
  90.     void change_mode(int *old_mode,int new_mode);
  91.     void SetVersion(void);
  92.  
  93.     // Messages from control panel
  94.     void     Idle(void);
  95.     void    Init(void);
  96.     void    Close(void);
  97.     void    Activate(void);
  98.     void    Update(void);
  99.     void    ItemHit(short);
  100.     void    Deactivate(void);
  101.     char    *CTXT(unsigned short idx);
  102. };
  103.  
  104. /*
  105.  * return a string from a resource
  106.  */
  107. char *SoftKiss::CTXT(unsigned short idx)
  108. {
  109.     return (char *)
  110.       (fs->dt.tptr+(*(fs->dt.tstrs+idx)));
  111. }
  112.  
  113. /*
  114.  *  Runnable - should the cdev appear in the Control Panel?
  115.  *
  116.  *  This implements the "macDev" message.
  117.  *
  118.  */
  119. Boolean Runnable()
  120. {
  121.     return true;
  122. }
  123.  
  124.  
  125. /*
  126.  *  New - create the cdev object
  127.  *
  128.  */
  129. cdev *New()
  130. {
  131.     return(new(SoftKiss));
  132. }
  133.  
  134. /*
  135.  * set ref_num for the driver refrence number
  136.  */
  137. void SoftKiss::find_driver()
  138. {
  139.      short err;
  140.      memset(fs->port_err,-1,sizeof(fs->port_err));
  141.     if((fs->ref_num=sfk_drvr_find(sfk_driver_name,0L))==0)
  142.         return;
  143.      err=OpenDriver(sfk_driver_name,&fs->ref_num);
  144.      if(err==0)
  145.          memset(fs->port_err,0,sizeof(fs->port_err));
  146.      else
  147.          fs->ref_num=0;
  148. }
  149.  
  150. /*
  151.  * send the passed message to the driver
  152.  */
  153. void SoftKiss::send_msg(int portno,char *msg,char *out_buf,long out_buf_size)
  154. {
  155.   sfk_io_record cmd;
  156.   int iErr;
  157.   sfk_INIT_CPB(cmd,fs->ref_num,sfk_CMD_msg);
  158.   out_buf[0]=0;
  159.   sfk_parse_from(&cmd,msg,strlen(msg),out_buf,out_buf_size,portno);
  160.   iErr = PBControlSync((ParmBlkPtr)&cmd);
  161.   fs->port_err[portno]=iErr;
  162.   if(iErr!=0)
  163.       working_SetIText(portno?fn_a_text:fn_b_text,out_buf);
  164. }
  165.  
  166. /*
  167.  * send the passed message to the driver
  168.  * Then read then update the controls to match the driver status
  169.  */
  170. void SoftKiss::send_cmd(int portno,char *msg)
  171. {
  172.   char out_buf[400];
  173.   if(fs->ref_num==0) {
  174.       SysBeep(20);
  175.       return;
  176.   }
  177.   send_msg(portno,msg,out_buf,sizeof(out_buf));
  178.   if(fs->port_err[portno]==0)    
  179.       read_driver_status(out_buf,sizeof(out_buf));
  180. }
  181.  
  182. /*
  183.  * change a port mode and update the display if it really changed
  184.  */
  185. void SoftKiss::change_mode(int *old_mode,int new_mode)
  186. {
  187.     char buf[3000];
  188.     if((*old_mode)==new_mode)
  189.         return;
  190.     *old_mode=new_mode;
  191.     set_display();
  192.     switch(fs->port_a_mode) {
  193.         case fn_a_off:
  194.           strcpy(buf,CTXT(1));
  195.           break;
  196.         case fn_a_kiss:
  197.           strcpy(buf,CTXT(2));
  198.           break;
  199.         case fn_a_tnc:
  200.           strcpy(buf,CTXT(3));
  201.           break;
  202.     }
  203.     working_SetIText(fn_a_text,buf);
  204.     switch(fs->port_b_mode) {
  205.         case fn_b_off:
  206.           strcpy(buf,CTXT(4));
  207.           break;
  208.         case fn_b_kiss:
  209.           strcpy(buf,CTXT(5));
  210.           break;
  211.         case fn_b_tnc:
  212.           strcpy(buf,CTXT(6));
  213.           break;
  214.     }
  215.     working_SetIText(fn_b_text,buf);
  216. }
  217.  
  218. /*
  219.  * read the device driver status of one port and update the display
  220.  */
  221. void SoftKiss::read_1_driver_status(int portno,char *out_buf,long out_buf_size)
  222. {
  223.     char *s=out_buf;
  224.     int kiss=FALSE;
  225.     int soft=FALSE;
  226.     send_msg(portno,CTXT(7),out_buf,out_buf_size);
  227.     if((s=strchr(s,' '))!=0) {
  228.         s++;
  229.         kiss= (*s)=='t';
  230.         if((s=strchr(s,' '))!=0)
  231.             soft= (*(s+1))=='t';
  232.     }
  233.     if(portno==sfk_PRINTER_PORT)
  234.         if(!soft)
  235.             change_mode(&fs->port_b_mode,fn_b_off);
  236.         else if(kiss)
  237.             change_mode(&fs->port_b_mode,fn_b_kiss);
  238.         else
  239.             change_mode(&fs->port_b_mode,fn_b_tnc);
  240.     else
  241.         if(!soft)
  242.             change_mode(&fs->port_a_mode,fn_a_off);
  243.         else if(kiss)
  244.             change_mode(&fs->port_a_mode,fn_a_kiss);
  245.         else
  246.             change_mode(&fs->port_a_mode,fn_a_tnc);
  247. }
  248.  
  249. /*
  250.  * read the device driver status and update the display
  251.  */
  252. void SoftKiss::read_driver_status(char *out_buf,long out_buf_size)
  253. {
  254.     read_1_driver_status(sfk_MODEM_PORT,out_buf,out_buf_size);
  255.     read_1_driver_status(sfk_PRINTER_PORT,out_buf,out_buf_size);
  256. }
  257.  
  258. /*
  259.  * idle message, update status area
  260.  */
  261. void SoftKiss::Idle()
  262. {
  263.     static long next_update=0;
  264.     long cur_ticks=TickCount();
  265.     if(fs->ref_num==0)
  266.         return;
  267.     if(cur_ticks<next_update)return;
  268.     next_update=cur_ticks+20;
  269.     {
  270.         char out_buf[400];
  271.         read_driver_status(out_buf,sizeof(out_buf));
  272.     }
  273. }
  274.  
  275. /*
  276.  * read in item list
  277.  */
  278. void SoftKiss::ReadItems(void)
  279. {
  280.   int i;
  281.   for(i=1;i<=fn_LAST;i++) {
  282.       a_ditem_pt ai= &fs->items[i];
  283.       GetDItem(dptr, lastItem + i, &ai->type, &ai->ctl, &ai->box);
  284.       }
  285. }
  286.  
  287. /*
  288.  * SetIText doesn't seem to invalidate....
  289.  */
  290. void SoftKiss::working_SetIText(int item,char *new_text)
  291. {
  292.   unsigned char buf[256];
  293.   int slen=strlen(new_text);
  294.   GrafPtr old_port;
  295.   slen=sfk_imin(slen,254);
  296.   buf[0]=slen;
  297.   memcpy(buf+1,new_text,slen);
  298. //  GetPort(&old_port);
  299. //  SetPort(&dp->port);
  300.   SetIText(fs->items[item].ctl,buf);
  301.   InvalRect(&fs->items[item].box);
  302. //  SetPort(old_port);
  303. }
  304.  
  305. /*
  306.  * set a checkbox as it is displayed
  307.  */
  308. void SoftKiss::set_item_hilite(int item,int setting)
  309. {
  310.     HiliteControl((ControlHandle)fs->items[item].ctl,(setting)?1:0);
  311. }
  312.  
  313. /*
  314.  * set a checkbox as it is displayed
  315.  */
  316. void SoftKiss::set_item_value(int item,int setting)
  317. {
  318.     SetCtlValue((ControlHandle)fs->items[item].ctl,(setting)?1:0);
  319.     if((fs->ref_num!=0)&&(fs->active))
  320.         HiliteControl((ControlHandle)fs->items[item].ctl,0);
  321.     else
  322.         HiliteControl((ControlHandle)fs->items[item].ctl,255);
  323. }
  324.  
  325. /*
  326.  * set the user interface to match fs.cstate
  327.  */
  328. void SoftKiss::set_display()
  329. {
  330.     set_item_value(fn_a_off,fs->port_a_mode==fn_a_off);
  331.     set_item_value(fn_a_kiss,fs->port_a_mode==fn_a_kiss);
  332.     set_item_value(fn_a_tnc,fs->port_a_mode==fn_a_tnc);
  333.  
  334.     set_item_value(fn_b_off,fs->port_b_mode==fn_b_off);
  335.     set_item_value(fn_b_kiss,fs->port_b_mode==fn_b_kiss);
  336.     set_item_value(fn_b_tnc,fs->port_b_mode==fn_b_tnc);
  337. }
  338.  
  339. /*
  340.  * allocate a dynamic text block
  341.  */
  342. static void *dt_aloc(unsigned long alloc_size)
  343. {
  344.     return NewPtr(alloc_size);
  345. }
  346.  
  347. /*
  348.  * free a dynamic text block
  349.  */
  350. static void dt_free(void *buf)
  351. {
  352.     DisposPtr(buf);
  353. }
  354.  
  355. /*
  356.  *  SoftKiss::Init
  357.  *
  358.  */
  359. void SoftKiss::Init()
  360. {
  361.     inherited::Init();
  362.     fs=(fs_t_pt)NewPtr(sizeof(*fs));
  363.     memset(fs,0,sizeof(*fs));
  364.     ReadItems();
  365.     GetIndPattern(fs->cdev_gray,sysPatListID,24);
  366.     fs->active=TRUE;
  367.     find_driver();
  368.     fs->port_a_mode=0;
  369.     fs->port_b_mode=0;        //make sure it updates
  370.     fs->init_done=TRUE;
  371.     if(!sfk_dt_load(1026,&fs->dt,dt_aloc,dt_free))
  372.         Error(cdevResErr);
  373.     SetVersion();
  374.     Idle();
  375. }
  376.  
  377.  
  378. /*
  379.  * at open time set the version text to match the vers resource
  380.  */
  381. void SoftKiss::SetVersion()
  382. {
  383.     Handle vers=Get1Resource('vers',1);
  384.     unsigned char ptext[256];
  385.     unsigned char len;
  386.     char *vers_str;
  387.     char *dst;
  388.     if(vers==0)return;
  389.     vers_str= (*vers)+6;
  390.       GetIText(fs->items[fn_title].ctl,ptext);
  391.       if(ptext[ptext[0]]!='#')
  392.           return;
  393.       len= (*vers_str++)&0x0F;
  394.       memcpy(&ptext[ptext[0]],vers_str,len);
  395.       ptext[0]+=len;
  396.       ptext[ptext[0]]=0;
  397.       working_SetIText(fn_title,(char*)&ptext[1]);
  398. }
  399.  
  400. /*
  401.  *  SoftKiss::Close
  402.  *
  403.  */
  404. void SoftKiss::Close()
  405. {
  406.     if(fs!=0)
  407.         DisposPtr((void*)fs);
  408.     fs=0;
  409.     inherited::Close();
  410. }
  411.  
  412. /*
  413.  *  SoftKiss::Update
  414.  *
  415.  */
  416. void SoftKiss::Update()
  417. {
  418.     a_ditem_pt aline;
  419.     int i;
  420.     PenNormal();
  421.     PenPat(fs->cdev_gray);
  422.     for(i=fn_line1;i<=fn_line2;i++) {
  423.         aline= &fs->items[i];
  424.         MoveTo(aline->box.left+1,aline->box.top);
  425.         LineTo(aline->box.right,aline->box.top);
  426.     }
  427. }
  428.  
  429. void SoftKiss::Activate()
  430. {
  431.     fs->active=TRUE;
  432.     set_display();
  433. }
  434.  
  435.  
  436. void SoftKiss::Deactivate()
  437. {
  438.     fs->active=FALSE;
  439.     set_display();
  440. }
  441.  
  442.  
  443. void SoftKiss::ItemHit(item)
  444. short item;
  445. {
  446.     Point where;
  447.  
  448.     switch(item) {
  449.     case fn_a_off:
  450.         send_cmd(sfk_MODEM_PORT,CTXT(8));
  451.         break;
  452.     case fn_a_kiss:
  453.         send_cmd(sfk_MODEM_PORT,CTXT(9));
  454.         break;
  455.     case fn_a_tnc:
  456.         send_cmd(sfk_MODEM_PORT,CTXT(10));
  457.         break;
  458.     case fn_b_off:
  459.         send_cmd(sfk_PRINTER_PORT,CTXT(11));
  460.         break;
  461.     case fn_b_kiss:
  462.         send_cmd(sfk_PRINTER_PORT,CTXT(12));
  463.         break;
  464.     case fn_b_tnc:
  465.         send_cmd(sfk_PRINTER_PORT,CTXT(13));
  466.         break;
  467.     default:
  468.         break;
  469.     }
  470.     set_display();
  471. }
  472.